
// 获取审核意见
import {
    getDetailApi
} from "@/wss/api/ContentReview";

//引入省市区数据的插件
import { CodeToText } from "element-china-area-data";

let arr = []
// 把数组转换成数组对象 数组的元素会变成对象value字段的值
function wssmixin(Vue) {

    Vue.mixin({
        // 
        computed: {
            transformNum: {
                get() {
                    return "";
                },
                async set(value) {
                    // console.log(value, "12321");
                    // haveOpininArr是评论过的数字
                    // value中的idStr是否再评论数组haveOpininArr中  这种写法需要点时间去理解🤗
                    const id = value.idStr || value.id

                    if (this.haveOpininArr.includes(id)) {

                        value.comment = true;

                    }
                    // console.log(value, "----------------vlaue---------------");

                },
            },
        },
        methods: {


            // 意见列表
            async getOpinionFnlist(_this, list) {
                let { data } = await getDetailApi({
                    docId: _this.$route.query.docId,
                    verifyId: _this.$route.query.verifyId,
                });
                _this.OpininArr = data;

                arr = []

                let start = null
                let end = null
                let Equal = null
                // 或者已经评论过的内容
                data.forEach((item, index) => {
                    let a = null
                    let temp = null
                    start = parseInt(item.startItemId.split("_")[1])
                    end = parseInt(item.endItemId.split("_")[1])
                    // 始终让startItemId小于endItemId
                    if (start > end) {
                        temp = item.startItemId
                        item.startItemId = item.endItemId
                        item.endItemId = temp

                    }
                    //Equal 防止startItemId与endItemId相同时，添加多一个
                    Equal = start == end ? true : false
                    start = null
                    end = null
                    for (let index = 0; index < list.length; index++) {
                        if (list[index].id === item.startItemId) {
                            arr.push(list[index].id)

                            a = true
                        } else {

                            if (list[index].id === item.endItemId) {
                                arr.push(list[index].id)

                                a = false
                                break
                                //Equal 防止startItemId与endItemId相同时，添加多一个
                            } else if (a && !Equal) {
                                arr.push(list[index].id)
                            }


                        }

                    }


                });


                this.haveOpininArr = arr
                // 数组去重

                _this.TorepeatFn(_this.haveOpininArr);

                _this.OpinionFnlist = data;
                // console.log(data, "失败原因列表");
                return arr

            },

        }
    })


}
/*
 把数组中的值转换成数组对象，对象中的value和label是原数组中的元素
 如对象中的value要和label不一样，就需要传入arr
 arr参数类似 [张三，李四，王五]
*/
export const arrTransformObj = (data, arr) => {
    if (!data) {
        return;
    }

    if (arr instanceof Array) {   //arr = [张三，李四，王五] 🧨注意顺序
        return data.map((item) => { // [1,2,3,4] => [{value:1,label:……},{value:2,label:……},{value:3,label:……}] label 
            return { value: item, label: arr[item] };
        });
    } else {
        return data.map((item) => { // [1,2,3,4] => [{value:1},{value:2},{value:3}]
            return { value: item, label: item };
        });
    }
}

export default wssmixin

// 大类型转换
export const changeType = (type) => {
    let lawArr = ["法规", "法条", "法则"];
    let flag = isNaN(Number(type));
    // 1 法律 2 问答 3 头条 4 合同 5 咨询 6项目

    if (flag) {

        if (lawArr.includes(type)) {
            return 1;
        } else if (type == "解答") {
            return 2;
        } else if (type == "合同") {
            return 4;
        } else if (type == "咨询") {
            return 5;
        } else if (type == "政策") {
            return 3;
        } else if (type == "项目") {
            return 6;

        }
    } else {
        if (type == 1) {

            return '法规';
        } else if (type == 2) {
            return "解答";
        } else if (type == 4) {
            return '合同'
        } else if (type == 5) {
            return '咨询'
        } else if (type == 3) {
            return '政策'
        } else if (type == 6) {
            return "项目";
        }
        else if (type == 20) {
            return "合同智审";
        }
        else if (type == 21) {
            return "诉讼模拟";
        }
        else if (type == 22) {
            return "阿米巴预算";
        }
        else if (type == 23) {
            return "合同文控";
        }
        else if (type == 25) {
            return "税账医生";
        }
        else if (type == 26) {
            return "CRM";
        }
        else if (type == 27) {
            return "微赞";
        }
        else if (type == 28) {
            return "微考勤";
        }
        else if (type == 29) {
            return "OKR";
        }
    }

}



// list = [{type:中文（法规）或者数字（1）}]
// 获取comform中类型的过滤参数
export function getfilterParams(list) {

    let arr = [], removeRepeat = [], i = 0;

    list.forEach((item, index) => {
        //过滤掉重复的
        if (removeRepeat.includes(item.type)) {

        } else {

            removeRepeat.push(item.type)
            if (typeof Number(item.type) == 'number') {
                // 是数字就转换成label的中文属性值
                arr.push({
                    label: changeType(item.type),
                });
                // 根据label转换成value
                arr[i].value = changeType(arr[i].label);
            } else {
                // 是中文就转换成value的数字
                arr.push({
                    value: changeType(item.type),
                });
                // 根据value转换成label
                arr[i].label = changeType(arr[i].value);
            }
            i++
        }


    });
    return arr

}

// 法律分类type	
export const changeLawType = (type) => {
    let lawArr = ["法规", "法条", "法则"];
    let flag = isNaN(Number(type));

    // flag 为true就是 字符串 false是数字
    if (flag) {
        if (lawArr.includes(type)) {
            return 1;
        } else if (type == "宪法") {
            return 2;
        } else if (type == "司法解释") {
            return 3;
        } else if (type == "行政法规") {
            return 4;
        } else if (type == "监察法规") {
            return 5;
        }
        else if (type == "决定") {
            return 6;
        }
        else if (type == "地方性法规") {
            return 7;
        }
        else if (type == "地方规章") {
            return 8;
        }
        else if (type == "部门规章") {
            return 9;
        }
        else if (type == "规范性文件") {
            return 10;
        }
        else if (type == "行业规范") {
            return 11;
        }
        else if (type == "行业标准") {
            return 12;
        }
    } else {
        if (type == 1) {

            return '法律';
        } else if (type == 2) {
            return "宪法";
        } else if (type == 3) {
            return '司法解释'
        } else if (type == 4) {
            return '行政法规'
        } else if (type == 5) {
            return '监察法规'
        } else if (type == 6) {
            return '决定'
        }
        else if (type == 7) {
            return '地方性法规'
        }

        else if (type == 8) {
            return '地方规章'
        }
        else if (type == 9) {
            return '部门规章'
        }
        else if (type == 10) {
            return '行业规范'
        }
        else if (type == 11) {
            return '行业规范'
        }
        else if (type == 12) {
            return '行业标准'
        }
    }

}
export const lawType = [{
    value: 1, label: "法律"
}, { value: 2, label: "宪法" },
{ value: 3, label: "司法解释" },
{ value: 4, label: "行政法规" },
{ value: 5, label: "监察法规" },
{ value: 6, label: "决定" },
{ value: 7, label: "地方性法规" },
{ value: 8, label: "地方规章" },
{ value: 9, label: "部门规章" },
{ value: 10, label: "规范性文件" },
{ value: 11, label: "行业规范" },
{ value: 12, label: "行业标准" }
]

// 协议
export const agreementArr = [
    {
        label: "专家宝典",
        value: "1",
    },
    {
        label: "商务宝典",
        value: "2",
    },
    {
        label: "ios隐私协议",
        value: "3",
    },
    {
        label: "ios用户协议",
        value: "4",
    },
    {
        label: "pc隐私协议",
        value: "5",
    },
    {
        label: "pc用户协议 ",
        value: "6",
    },
    {
        label: "安卓隐私协议",
        value: "7",
    },
    {
        label: "安卓用户协议",
        value: "8",
    },
    {
        label: "小程序隐私协议",
        value: "9",
    },
    {
        label: "小程序用户协议",
        value: "10",
    },
    {
        label: "免责声明",
        value: "11",
    },
    {
        label: "购买须知",
        value: "12",
    },
    {
        label: "认证说明",
        value: "13",
    },
]
var reader = new FileReader();
let base64Obj = {
    base64: ''
}
// 把file类型转换成base64
export function changeBase64Fn(file, fn) {


    reader.addEventListener(
        "load",
        function () {
            base64Obj.base64 = reader.result;
            fn(reader.result)
            // fn = null
        },
        false
    );

    if (file) {
        reader.readAsDataURL(file);
    }
    return base64Obj
}

export function changeFileToURLFn(file) {

    return URL.createObjectURL(file)
}
/**
 * 防抖函数
 * @param fn  要执行的函数
 * @param delay 延迟的时间
 */
var timer = null;
export function debounce(fn, delay) {

    return function () {
        clearTimeout(timer);
        timer = setTimeout(() => {
            fn.call(this);
        }, delay);
    };
}

/**
 * 节流函数
 * @param fn  要执行的函数
 * @param delay 延迟的时间
 */
export function throttle(fn, delay) {
    var lastTime = 0;
    return function () {
        var nowTime = Date.now();
        if (nowTime - lastTime > delay) {
            fn.call(this);
            lastTime = nowTime;
        }
    };
}



// /**
//  * 订单提示
//  * @param fn  要执行的函数
//  * @param delay 延迟的时间
//  */

//  export function orderTip(_this) {
//     if (condition) {

//     }
// } 
/**
 * 通过url转换成file文件
 * @param url  请求的url
 * @param fn 获取file的函数
 * @param fileName 生成文件的名字
 * 
 */
export function UrltoFile(url, fn, fileName = 'test') {
    fetch(url).then(result => {
        result.blob()
            .then(blob => {
                let reader = new FileReader();
                reader.onloadend = function () {
                    // 转换后的base64图片编码
                    let base = reader.result
                    // console.log(base);
                    let base64toFile = (base, filename) => {
                        
                        let arr = base.split(',');
                        let mime = arr[0].match(/:(.*?);/)[1];
                        let bstr = atob(arr[1]);
                        let n = bstr.length;
                        let u8arr = new Uint8Array(n);
                        while (n--) {
                            u8arr[n] = bstr.charCodeAt(n);
                        }
                        //转换成file对象
                        return new File([u8arr], filename, { type: mime });
                    }
                    let file = base64toFile(base, fileName)
                    fn(file)
                    fn = null
                };
                reader.readAsDataURL(blob)

            })


    })
}

// 通过url转换成file文件
export function getFileFromUrl(url, fileName) {
    return new Promise((resolve, reject) => {
        var blob = null;
        var xhr = new XMLHttpRequest();
        xhr.open("GET", url);
        xhr.setRequestHeader('Accept', 'image/png');
        xhr.responseType = "blob";
        // 加载时处理
        xhr.onload = () => {
            // 获取返回结果
            blob = xhr.response;
            let file= new File([blob], fileName, { type: 'image/png' });
            // 返回结果
            resolve(file);
        };
        xhr.onerror = (e) => {
            reject(e)
        };
        // 发送
        xhr.send();
    });
}


/**
 * 通过url转换成file文件
 * @param url  请求的url
 * @param PAttr 根据那个属性去筛选父类
 * @param orderAttr 同属性PAttr对象中找出那个是父类
 * 
 */
// export function switchTree(ilst = [], PAttr = 'group', orderAttr = 'no') {
//     console.log(ilst);
//     let list = JSON.parse(JSON.stringify(ilst))
//     let repet = []
//     let container = []
//     let i = null;
//     // 找出父项目
//     list.forEach(item => {
//         if (!repet.includes(item[PAttr])) {
//             repet.push(item[PAttr])
//             item.children = []
//             item.isPid = true
//             container.push(item)
//         } else {
//             container.find((pid, index) => {
//                 if (pid[PAttr] == item[PAttr] &&Number( pid[orderAttr]) > Number(item[orderAttr])) {
//                     container[index] = item
//                     container[index].isPid = true
//                     container[index].children = []
//                     return true
//                 }
//             })
//         }

//     })

//     // 找出子项
//     container.forEach(p => {
//         list.forEach(c => {
//             if (Object.is(p[PAttr], c[PAttr]) && (!Object.is(p.id, c.id))) {
//                 c.isPid = false
//                 p.children.push(c)
//                 return true
//             }
//         })
//     })
//     return container
// }

/**
 * 项目 通过arr数组转换成树状结构
 * @param arr  要转的数组
 * @param PAttr 根据那个属性去筛选父类
 * @param orderAttr 同属性PAttr对象中找出那个是父类
 * 
 */
export function switchTree(arr = []) {
    var map = {},
        dest = [];
    for (var i = 0; i < arr.length; i++) {
        var ai = arr[i];
        if (!map[ai.group]) {
            dest.push({ id: i, typeId: ai.typeId, isPid: true, group: ai.group, children: [ai] });
            map[ai.group] = ai;
        } else {
            for (var j = 0; j < dest.length; j++) {
                var dj = dest[j];
                if (dj.group == ai.group) {
                    dj.children.push(ai);
                    break;
                }
            }
        }
    }
    return dest
}

/**
 * 城市 通过arr数组转换成树状结构
 * @param arr  要转的数组
 * @param PAttr 根据那个属性去筛选父类
 * @param orderAttr 同属性PAttr对象中找出那个是父类
 * 
 */
export function cityTree(arr = []) {
    var map = {},
        dest = [];
    for (var i = 0; i < arr.length; i++) {
        var ai = arr[i];
        if (!map[ai.province]) {
            dest.push({ id: i, isPid: true, province: ai.province, city: ai.province, children: [ai] });
            map[ai.province] = ai;
        } else {
            for (var j = 0; j < dest.length; j++) {
                var dj = dest[j];
                if (dj.province == ai.province) {
                    dj.children.push(ai);
                    break;
                }
            }
        }
    }
    return dest
}

// 项目 更改记录 通过arr数组转换成树状结构
// 根据时间createTime
export function changeRecord(arr = []) {
    var map = {},
        dest = [];
    for (var i = 0; i < arr.length; i++) {
        var ai = arr[i];
        if (!map[ai.createTime]) {
            dest.push({ id: i, isPid: true, createName: ai.createName, createTime: ai.createTime, children: [ai] });
            map[ai.createTime] = ai;
        } else {
            for (var j = 0; j < dest.length; j++) {
                var dj = dest[j];
                if (dj.createTime == ai.createTime) {
                    dj.children.push(ai);
                    break;
                }
            }
        }
    }
    return dest
}

// 根据时间changeType 转树状
export function changeRecordType(arr = []) {
    var map = {},
        dest = [];
    for (var i = 0; i < arr.length; i++) {
        var ai = arr[i];
        if (!map[ai.changeType]) {
            dest.push({ id: i, isPid: true, createName: ai.createName, createTime: ai.createTime, changeType: ai.changeType, children: [ai] });
            map[ai.changeType] = ai;
        } else {
            for (var j = 0; j < dest.length; j++) {
                var dj = dest[j];
                if (dj.changeType == ai.changeType) {
                    dj.children.push(ai);
                    break;
                }
            }
        }
    }
    return dest
}

// 帮助设置根据 typeId 转树状
export function helpType(arr = []) {
    var map = {},
        dest = [];
    for (var i = 0; i < arr.length; i++) {
        var ai = arr[i];
        if (!map[ai.typeId]) {
            dest.push({ id: i, type: ai.type, typeId: ai.typeId, children: [ai] });
            map[ai.typeId] = ai;
        } else {
            for (var j = 0; j < dest.length; j++) {
                var dj = dest[j];
                if (dj.typeId == ai.typeId) {
                    dj.children.push(ai);
                    break;
                }
            }
        }
    }
    return dest
}

/**
 * 数字转中文
 * @param val 要转的数字
 * 
 */
export function TurnChinese(val) {
    let chin = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十']
    if (val <= 10) {
        return chin[val - 1]
    } else if (val <= 100) {
        if (val < 20) {
            return '十' + chin[(val % 10) - 1]
        } else if (val % 10 === 0) {
            return chin[Math.floor(val / 10) - 1] + '十'
        } else {
            return chin[Math.floor(val / 10) - 1] + '十' + chin[(val % 10) - 1]
        }
    }
}

//获取系统当前时间 yyyy-MM-dd hh:mm:ss
export function getNowFormatDate() {
    var date = new Date();
    var seperator1 = "-";
    var seperator2 = ":";
    var month = date.getMonth() + 1;
    var strDate = date.getDate();
    var hour = date.getHours()
    var minutes = date.getMinutes()
    var second = date.getSeconds()
    if (month >= 1 && month <= 9) {
        month = "0" + month;
    }
    if (strDate >= 0 && strDate <= 9) {
        strDate = "0" + strDate;
    }
    if (hour >= 0 && hour <= 9) {
        hour = "0" + hour;
    }
    if (minutes >= 0 && minutes <= 9) {
        minutes = "0" + minutes;
    }
    if (second >= 0 && second <= 9) {
        second = "0" + second;
    }
    var currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate
        + " " + hour + seperator2 + minutes
        + seperator2 + second;
    return currentdate;
}

// 直接下载文件 pdf
export function downloadfun(file_name, file_path) {
    var ajax = new XMLHttpRequest();
    ajax.open("GET", file_path, true);
    ajax.setRequestHeader("Cache-Control", "no-cache")
    ajax.setRequestHeader('Access-Control-Allow-Origin', '*');

    // window.webkit.messageHandlers.downloadFile.postMessage(file_path)

    ajax.responseType = 'blob';
    ajax.onload = e => {
        let res = e.target.response
        let blob = new Blob([res])
        let aLink = document.createElement("a")
        aLink.download = file_name // 下载文件的名字
        aLink.href = URL.createObjectURL(blob)
        aLink.click()
    }
    ajax.send()
}


// 时间搓转换
export const timestampConversion = {
    // 时间戳转换成天
    getDay(time) {
        let day = Math.floor(time / (1000 * 60 * 60 * 24))
        return day
    },
    // 时间戳转换成小时
    getHours(time) {
        let hours = Math.floor((time / (1000 * 60 * 60)) % 24)
        return hours
    },
    // 时间戳转换成分钟
    getMinutes(time) {
        let minutes = Math.floor((time / (1000 * 60 * 60)) % 24)
        return minutes
    },
    // 时间戳转换成秒
    getSeconds(time) {
        let seconds = Math.floor((time / (1000 * 60 * 60)) % 24)
        return seconds
    },
    // 时间戳转换日期
    format(time) {
        let day = Math.floor(time / (1000 * 60 * 60 * 24))
        let hours = Math.floor((time / (1000 * 60 * 60)) % 24)
        let minutes = Math.floor((time / (1000 * 60)) % 60)
        let seconds = Math.floor((time / 1000) % 60)
        return day + '天' + hours + '小时' + minutes + '分钟' + seconds + '秒'
    }
}

// 时间戳转换日期
export function timestampToTime(timestamp,isTime) {
    let tamp = timestamp
    //时间戳为10位需*1000，时间戳为13位的话不需乘1000
    if(tamp.length==10){
        tamp = tamp * 1000
    }
    var date = new Date(tamp);
    var Y = date.getFullYear() + '-';
    var M = (date.getMonth()+1 < 10 ? '0'+(date.getMonth()+1) : date.getMonth()+1) + '-';
    var D = date.getDate() + ' ';
    var h = date.getHours() + ':';
    var m = date.getMinutes() + ':';
    var s = date.getSeconds();
    if(isTime){
        return Y+M+D+h+m+s; //返回2022-10-01 时:分:秒
    }else{
        return Y+M+D; //返回2022-10-01 
    }
}

// 格式化时间 2022-11-01转为221101
export function getTimeFormat(days) {
    let arr = days.split("-");
    return arr[0].slice(2) + arr[1] + arr[2];
}

// 浮点数保留两位小数
// 将浮点数四舍五入，取小数点后2位
export function toDecimal(x) {
    if (x < 0.01) {
        return x
    } else {
        var f = parseFloat(x);
        if (isNaN(f)) {
            return;
        }
        f = Math.round(x * 100) / 100;
        return f;
    }
}

// 获取url的参数 http://localhost/aa?test="laotie" 调用getRequest(test) 可以获取laotie
export function getRequest(parName) {
    var str = parName.toLowerCase() + "=";
    var gvalue = "";
    var HREF = location.href;
    var upperHREF = location.href.toLowerCase();
    if (upperHREF.indexOf(str) > 0) {
        gvalue = HREF.substring(
            upperHREF.indexOf(str) + str.length,
            upperHREF.length
        );
        if (gvalue.indexOf("&") > 0)
            gvalue = gvalue.substring(0, gvalue.indexOf("&"));
        if (gvalue.indexOf("#") > 0) gvalue = gvalue.split("#")[0];
        gvalue = decodeURIComponent(gvalue);
    }
    return gvalue;
}


// (把dom元素保存成图片和复制到剪切板会使用到)图片转换格式的方法 直接使用就好 
export function dataURLToBlob(dataurl) {
    let arr = dataurl.split(',');
    let mime = arr[0].match(/:(.*?);/)[1];
    let bstr = atob(arr[1]);
    let n = bstr.length;
    let u8arr = new Uint8Array(n);
    while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
    }
    return new Blob([u8arr], { type: mime });
}

//num1 num2传入两个值  symbol +-*/符号
export function amend(num1, num2, symbol = "+") {
    var str1 = num1.toString(), str2 = num2.toString(), result, str1Length, str2Length
    //解决整数没有小数点方法
    try { str1Length = str1.split('.')[1].length } catch (error) { str1Length = 0 }
    try { str2Length = str2.split('.')[1].length } catch (error) { str2Length = 0 }
    var step = Math.pow(10, Math.max(str1Length, str2Length))
    // 

    switch (symbol) {
        case "+":
            result = (num1 * step + num2 * step) / step
            break;
        case "-":
            result = (num1 * step - num2 * step) / step
            break;
        case "*":
            result = ((num1 * step) * (num2 * step)) / step / step
            break;
        case "/":
            result = (num1 * step) / (num2 * step)
            break;
        default:
            break;
    }
    return result

}

// 传入时间转换成 format：yyyy-MM-dd 
export function transferTime(chinaStandard) {
    var date = new Date(chinaStandard);
    var y = date.getFullYear();
    var m = date.getMonth() + 1;
    m = m < 10 ? ('0' + m) : m;
    var d = date.getDate();
    d = d < 10 ? ('0' + d) : d;
    var h = date.getHours();
    var minute = date.getMinutes();
    minute = minute < 10 ? ('0' + minute) : minute;
    // let time = y + '-' + m + '-' + d +' '+h+':'+minute;  //这里如果不需要小时 分  后边的可以不需要拼接
    let time = y + '-' + m + '-' + d;  //这里如果不需要小时 分  后边的可以不需要拼接
    return time
}
// format：yyyy-MM-dd HH:mm:ss 
export function transferTimes(chinaStandard) {
    var date = new Date(chinaStandard);
    var y = date.getFullYear();
    var m = date.getMonth() + 1;
    m = m < 10 ? ('0' + m) : m;
    var d = date.getDate();
    d = d < 10 ? ('0' + d) : d;
    var h = date.getHours();
    h = h < 10 ? ('0' + h) : h;
    var minute = date.getMinutes();
    minute = minute < 10 ? ('0' + minute) : minute;
    var second = date.getSeconds();
    second = second < 10 ? ('0' + second) : second;
    // let time = y + '-' + m + '-' + d +' '+h+':'+minute;  //这里如果不需要小时 分  后边的可以不需要拼接
    let time = y + '-' + m + '-' + d + ' ' + h + ':' + minute + ':' + second;  //这里如果不需要小时 分  后边的可以不需要拼接
    return time
}

// 市的分类 根据城市编码分类 传入例如: '430100,430200,440100,440300'
export function inCityCodeClass(cityCode){
    if(!cityCode) return
    // 逗号分割
    let arr = cityCode.split(/[,,，]/)
    let topTwo = [] //省份的前两位
    let topFour = [] //市区的前两位
    // 获取省份编码前两位
    arr.forEach(item=>{
        topTwo.push(item.substring(0,2))
    })
    // 获取城市编码前四位
    arr.forEach(item=>{
        topFour.push(item.substring(0,4))
    })
    let newTopTwo = [...new Set(topTwo)]// 去重 省份编码前两位
    let newTopFour = [...new Set(topFour)]// 去重 市区的前两位
    let cityList = [] //城市数据集合
    // 对城市分类
    newTopTwo.forEach((item,i)=>{
        // 添加省份
        cityList.push({
            children:[],
            value: item + '0000',
            label: CodeToText[item + '0000']
        })
        // 添加城市
        newTopFour.forEach((k,index)=>{
            // 判断开头的省份前两位是否包含在当前这个城市的前两位
            if(k.startsWith(item)){
                cityList[i].children.push({
                    value: k + '00',
                    label: CodeToText[k + '00']
                })
            }
        })
    })
    return cityList
}

// 镇区的分类 根据镇区编码分类 传入例如: '441900003,441900004'
export function inAreaCodeClass(areaCode){
    if(!areaCode) return
    // 逗号分割
    let arr = areaCode.split(/[,,，]/)
    let topTwo = [] //省份的前两位
    let topFour = [] //市区的前两位
    // 获取省份编码前两位
    arr.forEach(item=>{
        topTwo.push(item.substring(0,2))
    })
    // 获取城市编码前四位
    arr.forEach(item=>{
        topFour.push(item.substring(0,4))
    })
    let newTopTwo = [...new Set(topTwo)]// 去重 省份编码前两位
    let newTopFour = [...new Set(topFour)]// 去重 市区的前两位
    let cityList = [] //最终数据集合
    // 对城市分类
    newTopTwo.forEach((item,i)=>{
        // 添加省份
        cityList.push({
            children:[],
            value: item + '0000',
            label: CodeToText[item + '0000']
        })
        // 添加城市
        newTopFour.forEach((k,index)=>{
            // 判断开头的省份前两位是否包含在当前这个城市的前两位
            if(k.startsWith(item)){
                cityList[i].children.push({
                    children:[],
                    value: k + '00',
                    label: CodeToText[k + '00']
                })
                arr.forEach(v=>{
                    // 判断开头的城市的前四位是否包含在当前这个镇区的前四位
                    if(v.startsWith(k)){
                        cityList[i].children[index].children.push({
                            value: v,
                            label: CodeToText[v]
                        })
                    }
                })
            }
        })
    })

    return cityList
}

/*** 校验只要是数字（包含正负整数，0以及正负浮点数）就返回true**/
export function isNumber(val){
    //校驗(小數/數字)正則表達式
    let pattern = /^[0-9]+([.]{1}[0-9]+){0,1}$/;
    if (pattern.test(val)) {
        return true
    } else {
        return false
    }
}


/* 
代码功能：获取当前年+所处周数
核心思想是：首先获得当前日期的周六日期，然后按照周六的日期来计算是第几周
周的定义：从周日开始，周六结束；每7天为一周
*/
export function getWeek(dateTime) {
    // 获取从1970年到现在的时间毫秒数
    var temp_ms = dateTime.getTime();
    let temptTime = new Date(temp_ms);
    // 今天周几，如果是周日，则设为7
    let weekday = temptTime.getDay() & 7;
    // 周1+5天=周六，得到本周6的日期,之所以以每周末的日期为基准，不能用每周日的日期为基准来计算
    // 当前日期的周六的日期
    temptTime.setDate(temptTime.getDate() - weekday + 1 + 5);
    // 每年的第一天，年/1/1，参数之中，0代表月份，介于0(1月) ~11(12月)之间的整数，getDay获取星期几同理
    // 第一天的日期
    let firstDay = new Date(temptTime.getFullYear(), 0, 1);
    let dayOfWeek = firstDay.getDay();
    let spendDay = 1;
    // 如果第一天不是星期日，那么就找到下一个星期日作为开始
    if (dayOfWeek != 0) {
      spendDay = 7 - dayOfWeek + 1;
    }
    let yearOfW = temptTime.getFullYear();
    firstDay = new Date(yearOfW, 0, 1 + spendDay);
    /*
    1.Math.ceil 取大于等于所给值的最小整数
    2.86400000是换算到天的基数，js的时间差值为时间戳，即毫秒数
      1000毫秒 * 60秒 * 60分钟* 24小时 = 86400000
    3.temptTime是当前日期，firstDay是当年第一天，周数计算公式就是（当前日期-第一天天数）/7 就是本年的第几周
    4.d是差距天数，res是周数
    */
    let d = Math.ceil((temptTime.valueOf() - firstDay.valueOf()) / 86400000);
    let res = Math.ceil(d / 7) + 1;
    let weekOfNow = firstDay.getFullYear().toString()+'年'+res.toString()+'周'
    return weekOfNow;
}